{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01. A2C\n",
    "[Mnih, Volodymyr, et al. \"Asynchronous methods for deep reinforcement learning.\" International conference on machine learning. 2016.](http://proceedings.mlr.press/v48/mniha16.pdf)\n",
    "\n",
    "### Actor-Critic\n",
    "\n",
    "*Actor critic* method is one of the popular *policy optimization* algorithms. This approach maximizes the expected return by pushing up the probabilities of actions that receive higher returns. Let $\\pi_\\theta$ denote a policy with parameters $\\theta$. The policy gradient of performance $\\mathcal{J}(\\pi_\\theta)$ is\n",
    "\n",
    "$$ \\nabla_\\theta \\mathcal{J}(\\pi_\\theta) = \\underset{\\tau\\sim\\pi_\\theta}{\\mathbb{E}}\\left[ \\sum^T_{t=0} \\nabla_\\theta \\log \\pi_\\theta(a_t|s_t)A^{\\pi_\\theta}(s_t, a_t) \\right],$$\n",
    "\n",
    "where $\\tau$ is a trajectory and $A^{\\pi_\\theta}$ is the advantage function for reducing variance of values. The *policy gradient algorithm* updates the parameters by adding this gradient.\n",
    "\n",
    "$$\\theta_{k+1} = \\theta_k + \\alpha \\nabla_\\theta \\mathcal{J}(\\pi_{\\theta_k}),$$\n",
    "\n",
    "where $\\alpha$ is a learning rate. The agent is trained in an on-policy way because the parameters are updated by the current policy. We call the policy *Actor* which predicts probabilities of actions in each state, and call the value function *Critic* that predicts values of all state-action pairs. \n",
    "\n",
    "\n",
    "### Advantage Function\n",
    "\n",
    "The advantage function effectively reduces the variance of values and is defined as follows.\n",
    "\n",
    "$$ A(s,a) = Q(s,a) - V(s) $$\n",
    "\n",
    "From this formula, we can replace Q with $r+\\gamma V(s')$ and redefine Advantage function without using Action-Value function.\n",
    "\n",
    "$$ A(s,a) = r + \\gamma V(s') - V(s) $$\n",
    "\n",
    "\n",
    "### Maximization Entropy\n",
    "\n",
    "Entropy is a measure of unpredictability or a measure of randomness. If we have actions with almost equal probabilities, the entropy over the actions will be the largest because it's completely unpredictable which action will be chosen. In view of the fact, we can encourage exploration by adding entropy maximization term to the loss function. The entropy $H$ with respect to the probability $p$ over actions is\n",
    "\n",
    "$$ H(P) = - \\sum_a p(a) \\log p(a) $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We will use two separated networks for actor and critic respectively. The actor network consists of one fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Normal distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value that is multiplied by 2 after tanh. On the one hand, the critic network has two fully connected layers as a hidden layer (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_uniformly(layer: nn.Linear, init_w: float = 3e-3):\n",
    "    \"\"\"Initialize the weights and bias in [-init_w, init_w].\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.mu_layer = nn.Linear(128, out_dim)     \n",
    "        self.log_std_layer = nn.Linear(128, out_dim)   \n",
    "        \n",
    "        initialize_uniformly(self.mu_layer)\n",
    "        initialize_uniformly(self.log_std_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        \n",
    "        mu = torch.tanh(self.mu_layer(x)) * 2\n",
    "        log_std = F.softplus(self.log_std_layer(x))\n",
    "        std = torch.exp(log_std)\n",
    "        \n",
    "        dist = Normal(mu, std)\n",
    "        action = dist.sample()\n",
    "        \n",
    "        return action, dist\n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        initialize_uniformly(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A2C Agent\n",
    "Here is a summary of A2CAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                   |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A2CAgent:\n",
    "    \"\"\"A2CAgent interacting with environment.\n",
    "        \n",
    "    Atribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        gamma (float): discount factor\n",
    "        entropy_weight (float): rate of weighting entropy into the loss function\n",
    "        device (torch.device): cpu / gpu\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        actor_optimizer (optim.Optimizer) : optimizer of actor\n",
    "        critic_optimizer (optim.Optimizer) : optimizer of critic\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, env: gym.Env, gamma: float, entropy_weight: float):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.entropy_weight = entropy_weight\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # networks\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.critic = Critic(obs_dim).to(self.device)\n",
    "        \n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=1e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition (state, log_prob, next_state, reward, done)\n",
    "        self.transition: list = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "        \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        state = torch.FloatTensor(state).to(self.device)\n",
    "        action, dist = self.actor(state)\n",
    "        selected_action = dist.mean if self.is_test else action\n",
    "\n",
    "        if not self.is_test:\n",
    "            log_prob = dist.log_prob(selected_action).sum(dim=-1)\n",
    "            self.transition = [state, log_prob]\n",
    "        \n",
    "        return selected_action.clamp(-2.0, 2.0).cpu().detach().numpy()\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition.extend([next_state, reward, done])           \n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> Tuple[torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"  \n",
    "        state, log_prob, next_state, reward, done = self.transition\n",
    "\n",
    "        # Q_t   = r + gamma * V(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        mask = 1 - done\n",
    "        next_state = torch.FloatTensor(next_state).to(self.device)\n",
    "        pred_value = self.critic(state)\n",
    "        targ_value = reward + self.gamma * self.critic(next_state) * mask\n",
    "        value_loss = F.smooth_l1_loss(pred_value, targ_value.detach())\n",
    "        \n",
    "        # update value\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        value_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        # advantage = Q_t - V(s_t)\n",
    "        advantage = (targ_value - pred_value).detach()  # not backpropagated\n",
    "        policy_loss = -advantage * log_prob\n",
    "        policy_loss += self.entropy_weight * -log_prob  # entropy maximization\n",
    "\n",
    "        # update policy\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        policy_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        return policy_loss.item(), value_loss.item()\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        actor_losses, critic_losses, scores = [], [], []\n",
    "        state = self.env.reset()\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "            \n",
    "            actor_loss, critic_loss = self.update_model()\n",
    "            actor_losses.append(actor_loss)\n",
    "            critic_losses.append(critic_loss)\n",
    "            \n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0                \n",
    "            \n",
    "            # plot\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(self.total_step, scores, actor_losses, critic_losses)\n",
    "        self.env.close()\n",
    "    \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "num_frames = 100000\n",
    "gamma = 0.9\n",
    "entropy_weight = 1e-2\n",
    "\n",
    "agent = A2CAgent(env, gamma, entropy_weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -3.4951092131619883\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgYQQUGUSPEVIZCKOV\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderYQQUGUSPEVIZCKOV\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animYQQUGUSPEVIZCKOV.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animYQQUGUSPEVIZCKOV.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectYQQUGUSPEVIZCKOV\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgYQQUGUSPEVIZCKOV\";\n",
       "    var slider_id = \"_anim_sliderYQQUGUSPEVIZCKOV\";\n",
       "    var loop_select_id = \"_anim_loop_selectYQQUGUSPEVIZCKOV\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animYQQUGUSPEVIZCKOV = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rl-is-all-you-need",
   "language": "python",
   "name": "rl-is-all-you-need"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
